import importlib
from copy import deepcopy
from operator import index
from pyclbr import Function
from typing import Dict, List, Union
from uuid import uuid1
from utils.exception import ResponseException

from core.basic.equipment import equipment, get_equ, get_global_data
from core.basic.property import CharacterProperty
from core.basic.skill import 主动技能, 技能, 被动技能
from core.equipment.avatar import 装扮套装, 装扮套装集合, 装扮集合
from core.equipment.emblems import get_emblems_setinfo
from core.equipment.enchanting import get_enchanting_setinfo
from core.equipment.jade import get_jade_setinfo
from core.equipment.property import (增幅计算, 左右计算, 成长词条计算, 武器强化计算, 精通计算,
                                     耳环计算, 获取基础属性, 获取属性抗性基础, 获取异常抗性基础, 辅助精通计算,
                                     部位列表, 锻造四维, 锻造计算)
from core.equipment.sundry import get_sundries_setinfo
from core.store import store

# from core.basic.enchanting import get_encfunc_by_id
# from core.basic.emblems import get_embfunc_by_id
# from core.basic.jade import get_jadefunc_by_id


class Character(CharacterProperty):
    等级 = 110
    # 辟邪玉属性
    附加伤害增加增幅: float = 1.0
    属性附加伤害增加增幅: float = 1.0
    技能伤害增加增幅: float = 1.0
    暴击伤害增加增幅: float = 1.0
    伤害增加增幅: float = 1.0
    最终伤害增加增幅: float = 1.0
    力量智力增加增幅: float = 1.0
    物理魔法攻击力增加增幅: float = 1.0
    所有属性强化增幅: float = 1.0
    version = "default"
    equVersion = ""

    等级: int = 110
    防御输入: int = 506109
    防御系数: int = 1
    火抗输入: int = 0
    冰抗输入: int = 0
    光抗输入: int = 0
    暗抗输入: int = 0
    打造详情: Dict[str, Dict[str, int]] = {}
    装备栏: List[int] = []  # [装备id]
    部位装备: Dict[str, int] = {}  # {部位: 装备id}
    部位附魔: Dict[str, Function] = {}  # {部位: 附魔函数}
    词条等级: Dict[str, List[int]] = {}  # {部位: [等级1, 2, 3, 4]}
    药剂: List[int] = []

    # 需要职业自定义数据
    实际名称 = ''
    名称 = ''
    角色 = ''
    角色类型 = ''
    职业 = ''
    武器选项: List[str] = []
    输出类型选项: List[str] = []
    防具精通属性: List[str] = []
    排行类型 = '物理百分比'
    适用属性 = '智力'
    适用数值 = 0
    类型 = ''
    武器类型 = ''
    防具类型 = ''
    转职 = ''
    # 技能栏: List[技能 | 主动技能 | 被动技能] = []
    # 技能序号: Dict[int, 技能 | 主动技能 | 被动技能] = {}
    技能栏: List[Union[技能, 主动技能, 被动技能]] = []
    技能序号: Dict[str, int] = {}
    自定义词条: Dict[int, List[int]] = {}
    buff: float = 1.00
    hotkey: List[str] = [""]*14
    技能队列 = []
    护石技能 = []
    护石栏 = []
    符文 = []
    skills_passive: Dict = {}
    融合列表 = []
    武器融合 = []

    装扮栏: Dict[str, int] = {}
    装扮选项: Dict[str, str] = {}

    # 职业技能特殊选项
    individuation: Dict[str, int] = {}

    技攻列表: Dict[str, List[float]] = {}

    打造: Dict = {}
    觉醒技能 = []
    冷却缩减 = 1.0
    冷却恢复 = 0.0
    tip_part: List[str] = []
    trigger_set = {}
    eq_params = {}
    suits = []

    def __init__(self, equVersion="") -> None:
        self.equVersion = equVersion
        self.eq_params = {}
        # 计算变量 ##########
        self.__基础力量: int = 0
        self.__基础智力: int = 0
        self.__基础体力: int = 0
        self.__基础精神: int = 0

        self.__进图力量: int = 0
        self.__进图智力: int = 0
        self.__进图体力: int = 0
        self.__进图精神: int = 0
        self.__进图三攻: int = 0
        self.__BUFF补正智力: int = 0
        self.__BUFF补正体力: int = 0
        self.__BUFF补正精神: int = 0

        self.__力量: int = 0
        self.__智力: int = 0
        self.__体力: int = 0
        self.__精神: int = 0

        self.系统奶系数: float = 0.0
        self.系统奶基数: float = 0.0

        self.冷却缩减 = 1.0
        self.冷却恢复 = 0

        self.斗神宠物 = 1.0
        # self.年宠技能 = False
        # self.白兔子技能 = False
        # self.斗神之吼秘药 = False

        self.辅助对象力智 = 5000
        self.辅助对象三攻 = 3000

        self.__物理攻击力: int = 65
        self.__魔法攻击力: int = 65
        self.__独立攻击力: int = 1134
        self.__火属性强化: float = 13
        self.__冰属性强化: float = 13
        self.__光属性强化: float = 13
        self.__暗属性强化: float = 13

        # 旧词条
        self.__百分比力智: float = 0.0
        self.__百分比三攻: float = 0.0
        self.__伤害增加: float = 0.0
        self.__附加伤害: float = 0.0
        self.__属性附加: float = 0.0
        self.__暴击伤害: float = 0.0
        self.__最终伤害: float = 0.0
        self.技能攻击力: float = 1.0
        self.__面板技能攻击力: float = 1.0
        self.技能攻击力累加: float = 0.0
        self.__持续伤害: float = 0.0
        self.__加算冷却缩减: float = 0.0
        self.__百分比减防: float = 0.0
        self.__固定减防: int = 0
        self.__buff固定力智: int = 0
        self.__buff百分比力智: float = 1.0
        self.__buff固定三攻: int = 0
        self.__buff百分比三攻: float = 1.0

        self.__觉醒固定力智: int = 0
        self.__觉醒百分比力智: float = 1.0
        self.__觉醒百分比力智Total:float = 1.0

        # 其它词条
        self.__攻击速度: float = 0.00
        self.__攻击速度_其他 :float = 0.00
        self.__移动速度: float = 0.00
        self.__施放速度: float = 0.00
        self.__命中率: float = 0.0
        self.__回避率: float = 0.0
        self.__物理暴击率: float = 0.00
        self.__魔法暴击率: float = 0.00
        self.__火属性抗性: int = 0
        self.__冰属性抗性: int = 0
        self.__光属性抗性: int = 0
        self.__暗属性抗性: int = 0

        self.属强抗性倍率 = 1.0

        # 新属性
        self.__攻击强化: int = 0
        self.__百分比攻击强化: float = 0.0
        self.__buff量: int = 0
        self.__百分比buff量: float = 0.0
        self.__基础精通倍率: float = 1.0
        self.伤害比例: Dict[str, float] = {
            '直伤': 1.0, '中毒': 0.0, '灼伤': 0.0, '感电': 0.0, '出血': 0.0}
        self.伤害系数: Dict[str, float] = {
            '中毒': 1.0, '灼伤': 1.0, '感电': 1.0, '出血': 1.0}
        self.特效 = []
        self.__异常抗性: Dict[str, float] = {}
        self.__异常抗性_职业基础: Dict[str, float] = {}
        self.__指令效果: Dict[str, float] = {}
        self.__MP消耗量: float = 1.0
        self.觉醒技能 = []

        self.skills_passive = {}
        self.异常基础加成 = {
            '中毒': 1.1,
            '灼伤': 1.0,
            '感电': 1.05,
            '出血': 1.1 ,
            '灼伤破冰':1.1
            }
        self.异常结算加成 = {
            '中毒': 1.0,
            '灼伤': 1.0,
            '感电': 1.0,
            '出血': 1.0,
            '灼伤破冰':1.0
        }
        self.异常时间 = {
            # 基础持续时间 持续时间增加值 持续时间增加率 CD
            '中毒':[5,0,1.0,99],
            '灼伤':[5,0,1.0,99],
            '感电':[10,0,1.0,99],
            '出血':[3,0,1.0,99],
            '冰冻':[5,0,10,99]
        }
        self.打造 = {}
        self.trigger_set = {}
        for item in 部位列表 + ('称号', '宠物'):
            self.打造[item] = {
                # 成长
                "attack": [0]*4,
                # 成长
                "buffer": [0]*4,
                # 强化
                "强化四维": [0]*4,
                # 增幅
                "增幅四维": [0]*4,
                # 攻击力
                "强化攻击力": [0]*3,
                # 独立,四维
                "锻造加成": [0]*2,
                "params": [[None]]*4,
                "tips": []
            }

        self.tip_part = []
        if self.转职 == '':
            self.转职 = self.职业

        # 设置基础属性
        self.__设置基础属性()
        self.技攻列表 = {}

    def __设置基础属性(self):
        temp = 获取基础属性(self.角色, self.职业)
        self.__基础力量 = temp[0]
        self.__基础智力 = temp[1]
        self.__基础体力 = temp[2]
        self.__基础精神 = temp[3]

        self.__力量 = self.__基础力量
        self.__智力 = self.__基础智力
        self.__体力 = self.__基础体力
        self.__精神 = self.__基础精神

        temp = 获取属性抗性基础(self.角色, self.职业)
        self.__火属性抗性 += temp[0]
        self.__冰属性抗性 += temp[1]
        self.__光属性抗性 += temp[2]
        self.__暗属性抗性 += temp[3]

        temp = 获取异常抗性基础(self.角色, self.职业)

        异常状态 = ['出血', '中毒', '灼伤', '感电',  '冰冻', '减速',
                '眩晕', '诅咒', '失明', '石化', '睡眠', '混乱', '束缚']
        for index in range(0, len(异常状态)):
            self.异常抗性加成(异常状态[index], temp[index], mode=0)

    def 职业特殊设置(self):
        pass
    # region 返回前端信息

    def getinfo(self) -> Dict:
        info = {}
        info["alter"] = self.实际名称
        info["version"] = self.version
        info["name"] = self.名称
        info["character"] = self.职业
        info["role"] = 'buffer' if self.类型 == '辅助' else 'delear'
        info["weapon_types"] = self.武器选项
        info["carry_type_list"] = self.输出类型选项
        info["armor"] = self.防具类型
        info["armor_mastery"] = self.防具精通属性
        info["buff_ratio"] = self.buff
        self.set_skill_info(info)
        self.set_individuation(info)
        dress_list = {}
        i = 0
        for dress in 装扮集合:
            部位 = dress.部位
            if 部位 not in dress_list:
                dress_list[部位] = []
            选项集合 = dress.选项集合
            if dress.部位 == '上衣':
                选项集合 = 选项集合 + tuple(info['clothes_coat'])
            elif dress.部位 == '下装':
                选项集合 = 选项集合 + tuple(info['clothes_pants'])
            data = {}
            data['id'] = i
            data['options'] = 选项集合
            data['part'] = 部位
            data['rarity'] = dress.品质
            data['suit'] = dress.套装
            data['name'] = "{品质}装扮{部位}".format(品质=dress.品质, 部位=dress.部位)
            i += 1
            dress_list[部位].append(data)
        info['dress'] = dress_list
        info['enchanting'] = get_enchanting_setinfo(self)
        info['emblem'] = get_emblems_setinfo(self)
        info['jade'] = get_jade_setinfo()
        info["especificity"] = get_equ(self.equVersion).get_funs_info('specificity', self)
        info['sundries'] = get_sundries_setinfo()

        for item in info['platinum']:
            info['emblem'].append({
                'id': item,
                'maxFame': 232,
                'position': ["辅助装备", "魔法石"],
                'props': item + " Lv+1" + " 四维 + 8",
                'type': "技能",
                'rarity': "白金",
                'rate': 2000
            })
        return info

    def set_skills(self):
        pass

    def get_acitve_skill_detail(self, skill, temp_info, temp_char, weapon, ratio, skill_info):
        if skill.是否有伤害:
            if len(skill.形态) == 0:
                skill.形态 = ['']
            if self.实际名称 == 'elven_knight' and len(list(filter(lambda x:'6c' in x,skill.形态)))>0:
                skill.形态 = list(filter(lambda x:'6c' in x,skill.形态))
            for 形态 in skill.形态:
                original = 0
                for i in ['直伤', '中毒', '灼伤', '感电', '出血']:
                    original += skill.等效百分比(
                        char=temp_info, 武器类型=weapon, 形态=形态, 伤害类型=i)
                skill_info["skills_active"].append({
                    "name": skill.名称,
                    "need_level": skill.所在等级,
                    "lv": skill.等级,
                    "data": original*ratio*skill.被动倍率,
                    "cd": skill.等效CD(武器类型=weapon, 输出类型=temp_info.类型),
                    "mode": 形态,
                    "cost": skill.无色消耗,
                    "tp": skill.TP等级
                })
                if skill.是否有护石 == 1:
                    temp = temp_char.get_skill_by_name(skill.名称)
                    cp = 0
                    for i in ['直伤', '中毒', '灼伤', '感电', '出血']:
                        cp += temp.等效百分比(char=temp_char,
                                         武器类型=weapon, 形态=形态, 伤害类型=i)
                    skill_info["skills_cp"].append({
                        "name": skill.名称,
                        "need_level": skill.所在等级,
                        "lv": skill.等级,
                        "data": cp*ratio*temp.被动倍率,
                        "cd": temp.等效CD(武器类型=weapon, 输出类型=temp_info.类型),
                        "original_data": original*ratio*skill.被动倍率,
                        "original_cd": skill.等效CD(武器类型=weapon, 输出类型=temp_info.类型),
                        "mode": 形态,
                        "cost": temp.无色消耗,
                        "tp": skill.TP等级
                    })
                pass
            pass

    def get_passive_skill_detail(self, skill, temp_info):
        if temp_info.类型 == '物理百分比':
            倍率 = skill.物理攻击力倍率(temp_info.武器类型)
            if 倍率 != 1:
                temp_info.skills_passive[skill.名称]['info'].append({
                    "type": "物理攻击力",
                    "info": [round((倍率-1)*100), '所有', '']
                })
            倍率 = skill.物理攻击力倍率进图(temp_info.武器类型)
            if 倍率 != 1:
                temp_info.skills_passive[skill.名称]['info'].append({
                    "type": "物理攻击力[进图]",
                    "info": [round((倍率-1)*100), '所有', '']
                })
        elif temp_info.类型 == '魔法百分比':
            倍率 = skill.魔法攻击力倍率(temp_info.武器类型)
            if 倍率 != 1:
                temp_info.skills_passive[skill.名称]['info'].append({
                    "type": "魔法攻击力",
                    "info": [round((倍率-1)*100), '所有', '']
                })
            倍率 = skill.魔法攻击力倍率进图(temp_info.武器类型)
            if 倍率 != 1:
                temp_info.skills_passive[skill.名称]['info'].append({
                    "type": "魔法攻击力[进图]",
                    "info": [round((倍率-1)*100), '所有', '']
                })

        elif temp_info.类型 == '物理固伤' or temp_info.类型 == '魔法固伤':
            倍率 = skill.独立攻击力倍率(temp_info.武器类型)
            if skill.名称 not in temp_info.skills_passive:
                return
            if 倍率 != 1:
                temp_info.skills_passive[skill.名称]['info'].append({
                    "type": "独立攻击力",
                    "info": [round((倍率-1)*100), '所有', '']
                })
            倍率 = skill.独立攻击力倍率进图(temp_info.武器类型)
            if skill.名称 not in temp_info.skills_passive:
                return
            if 倍率 != 1:
                temp_info.skills_passive[skill.名称]['info'].append({
                    "type": "独立攻击力[进图]",
                    "info": [round((倍率-1)*100), '所有', '']
                })

    def 设置觉醒技能(self):
        self.觉醒技能 = []
        for i in self.技能栏:
            if i.是否有伤害 == 1 and i.所在等级 in [50,85,100]:
                self.觉醒技能.append(i.名称)


    def getskillinfos(self):
        # 技能等级、技能TP
        for skill in self.技能栏:
            if skill.是否有伤害:
                skill.TP等级 = skill.TP上限
            skill.等级 = skill.基础等级
        # 宠物
        self.加算冷却缩减(0.05)
        self.技能等级加成('所有', 1, 95, 1)
        # 光环
        self.技能等级加成('所有', 1, 95, 1)
        # 至尊称号
        self.技能等级加成('被动', 95, 95, 1)
        self.职业特殊设置()
        # 白金、时装、BUFF
        self.set_skills()

        for skill in self.技能栏:
            self.skills_passive[skill.名称] = {
                "info": [],
                "lv": skill.等级,
                "need_lv": skill.所在等级
            }

        self.加算冷却计算()

        ratio = self.buff

        infos = []
        for weapon in self.武器选项:
            temp_info = deepcopy(self)
            temp_char = deepcopy(self)
            temp_char.护石栏 = []
            for skill in temp_char.技能栏:
                if skill.是否有伤害 and skill.是否有护石 == 1:
                    temp_char.护石栏.append(skill.名称)
                    skill.装备护石(char=self)
            temp_info.武器类型 = weapon
            temp_info.职业特殊计算()
            temp_info.被动倍率计算()
            if self.类型 == '物理百分比':
                ratio *= temp_info.站街物理攻击力倍率()*temp_info.进图物理攻击力倍率()
            elif self.类型 == '魔法百分比':
                ratio *= temp_info.站街魔法攻击力倍率()*temp_info.进图魔法攻击力倍率()
            elif self.类型 == '物理固伤':
                ratio *= temp_info.站街独立攻击力倍率()*temp_info.进图独立攻击力倍率()
            elif self.类型 == '魔法固伤':
                ratio *= temp_info.站街独立攻击力倍率()*temp_info.进图独立攻击力倍率()
            temp_info.CD倍率计算()
            temp_info.伤害指数计算()
            temp_char.武器类型 = weapon
            temp_char.职业特殊计算()
            temp_char.被动倍率计算()
            temp_char.CD倍率计算()
            temp_char.伤害指数计算()
            skill_info = {
                "weapon": weapon,
                "skills_active": [],
                "skills_passive": [],
                "skills_cp": [],
                "type": temp_info.类型,
                "buff": temp_info.buff
            }
            for skill in temp_info.技能栏:
                self.get_acitve_skill_detail(
                    skill, temp_info, temp_char, weapon, ratio, skill_info)
                self.get_passive_skill_detail(skill, temp_info)
            for i in temp_info.skills_passive:
                skill = temp_info.skills_passive[i]
                if len(skill['info']) > 0:
                    for item in skill['info']:
                        skill_info["skills_passive"].append({
                            "name": i,
                            "need_level": skill['need_lv'],
                            "lv": temp_info.get_skill_by_name(i).等级,
                            "data": item['info'][0],
                            "type": item['type'],
                            "remark": "{}{}".format("、".join(item['info'][1].split(",")), "({}除外)".format("、".join(item['info'][2].split(","))) if item['info'][2] != "无" and item['info'][2] != "" and item['info'][2] != 0 else "")
                        })
            infos.append(skill_info)
        return infos

    def 基础属性加成(self,
               物理攻击力=0.00, 魔法攻击力=0.00, 独立攻击力=0.00, 三攻=0,
               力量=0.00, 智力=0, 力智=0, 体力=0, 精神=0, 体精=0, 四维=0,
               物理暴击率=0.00, 魔法暴击率=0.00, 暴击率=0.00,
               攻击速度=0.00, 施放速度=0.00, 移动速度=0.00,   三速=0.00, 火属性抗性=0, 光属性抗性=0, 冰属性抗性=0, 暗属性抗性=0, 所有属性抗性=0, 所有异常抗性=0, 所有职业异常抗性=0, 进图力量=0.00, 进图智力=0.00,
               **kwargs):
        self.__物理攻击力 += 物理攻击力 + 三攻
        self.__魔法攻击力 += 魔法攻击力 + 三攻
        self.__独立攻击力 += 独立攻击力 + 三攻
        self.__力量 += 力量 + 力智 + 四维
        self.__智力 += 智力 + 力智 + 四维
        self.__体力 += 体力 + 体精 + 四维
        self.__精神 += 精神 + 体精 + 四维
        self.__物理暴击率 += float(物理暴击率) + float(暴击率)
        self.__魔法暴击率 += float(魔法暴击率) + float(暴击率)
        self.__攻击速度 += float(攻击速度) + float(三速)
        self.__施放速度 += float(施放速度) + float(三速)
        self.__移动速度 += float(移动速度) + float(三速)
        self.__火属性抗性 += 火属性抗性+所有属性抗性
        self.__光属性抗性 += 光属性抗性+所有属性抗性
        self.__冰属性抗性 += 冰属性抗性+所有属性抗性
        self.__暗属性抗性 += 暗属性抗性+所有属性抗性
        self.__进图力量 += 进图力量
        self.__进图智力 += 进图智力
        for 类型 in ['中毒', '灼伤', '感电', '出血', '冰冻', '减速', '眩晕', '诅咒', '失明', '石化', '睡眠', '混乱', '束缚']:
            self.__异常抗性[类型] = self.__异常抗性.get(类型, 0.0) + 所有异常抗性
            self.__异常抗性_职业基础[类型] = self.__异常抗性_职业基础.get(类型, 0.0) + 所有职业异常抗性
        super().基础属性加成(物理攻击力, 魔法攻击力, 独立攻击力, 三攻,
                       力量, 智力, 力智, 体力, 精神, 体精, 四维,
                       物理暴击率, 魔法暴击率, 暴击率,
                       攻击速度, 施放速度, 移动速度, 三速, 火属性抗性, 光属性抗性, 冰属性抗性, 暗属性抗性, 所有属性抗性, 所有异常抗性, 所有职业异常抗性, 进图力量, 进图智力)

    def set_skill_info(self, info, rune_except=[], clothes_pants=[], rune_start_lv=20) -> None:
        skillInfo = []  # 技能
        rune = []  # 符文
        talisman = []  # 护石
        platinum = []  # 白金
        clothes_coat = []  # 时装
        for skill in self.技能栏:
            skill.等级 = skill.基础等级
            skillInfo.append({
                "name": skill.名称,
                "type": skill.是否有伤害,
                "need_level": skill.所在等级,
                "level_master": skill.等级精通,
                "level_max": skill.等级上限,
                "cooldown": 0 if not skill.是否有伤害 else (skill.CD[skill.等级] if isinstance(skill.CD, list) else skill.CD),
                "current_level": skill.基础等级,
                "data": 0 if not skill.是否有伤害 else skill.等效百分比(char=self),
                "tp_max": skill.TP上限 if skill.是否有伤害 else None,
                "tp_level": skill.TP等级 if skill.是否有伤害 else None,
                "mode": [] if not skill.是否有伤害 else skill.形态
            })
            # 护石
            if skill.是否有伤害 == 1 and skill.是否有护石 == 1:
                talisman.append(skill.名称)
            # 符文
            if skill.所在等级 >= rune_start_lv and skill.所在等级 <= 80 and skill.所在等级 != 50 and (skill.是否有伤害 == 1 or (skill.是否主动 == 1 and self.类型 == '辅助')) and skill.名称 not in rune_except:
                rune.append(skill.名称)
            # 白金
            if skill.所在等级 >= 15 and skill.所在等级 <= 70 and skill.所在等级 not in [48, 50]:
                platinum.append(skill.名称)
            # 时装
            if skill.所在等级 <= 95:
                clothes_coat.append(skill.名称)
        if self.类型 == '辅助':
            talisman += self.护石技能
        info['skills'] = skillInfo
        info['rune'] = rune
        info['talisman'] = talisman
        info['platinum'] = platinum
        info['clothes_coat'] = clothes_coat
        info['clothes_pants'] = clothes_pants

    def set_individuation(self, info) -> None:
        pass

    # endregion

    # region 词条属性
    def set_eq_params(self, key, value):
        self.eq_params[key] = value

    def add_eq_params(self, key, value,default = 0):
        self.eq_params[key] = self.eq_params.get(key,default) + value

    def multiply_eq_params(self, key, value,default = 1):
        self.eq_params[key] = self.eq_params.get(key,default) * value

    def get_eq_params(self, key,default = 0):
        return self.eq_params.get(key, default)

    def 基础精通加成(self, x: float) -> None:
        self.__基础精通倍率 *= 1+x

    def 百分比防御减少(self, x: float) -> None:
        self.__百分比减防 += x

    def 固定防御减少(self, x: int) -> None:
        self.__固定减防 += x

    def 伤害类型转化(self, 类型1: str, 类型2: str, x: float) -> None:
        # 直伤 中毒 灼伤 感电 出血
        # if self.伤害比例.get(类型1, 0.0) - x <= 0:
        #     pass
        self.伤害比例[类型1] = max(self.伤害比例.get(类型1, 0.0) - x,0)
        self.伤害比例[类型2] = self.伤害比例.get(类型2, 0.0) + x

    def 异常增伤(self, 类型: str, x: float) -> None:
        # 中毒 灼伤 感电 出血
        self.伤害系数[类型] = self.伤害系数.get(类型, 1.0) + x

    def 异常抗性加成(self, 类型: str, x: float, mode: int = 1) -> None:
        # 中毒 灼伤 感电 出血 冰冻 减速 眩晕 诅咒 失明 石化 睡眠 混乱 束缚
        if mode == 1:
            self.__异常抗性[类型] = self.__异常抗性.get(类型, 0.0) + x
        else:
            self.__异常抗性_职业基础[类型] = self.__异常抗性_职业基础.get(类型, 0.0) + x

    def 异常抗性获取(self, 类型: str, mode: int = 1) -> float:
        # mode = 1 显示抗性 mode = 0 装备加成抗性
        return round(self.__异常抗性.get(类型, 0.0) + (self.__异常抗性_职业基础.get(类型, 0.0) if mode == 1 else 0.0), 4)

    def 属性攻击(self, 类型: str) -> None:
        pass

    def 所有异常抗性加成(self, x: float, mode: int = 1) -> None:
        for 类型 in ['中毒', '灼伤', '感电', '出血', '冰冻', '减速', '眩晕', '诅咒', '失明', '石化', '睡眠', '混乱', '束缚']:
            self.异常抗性加成(类型,x,mode)

    def 指令效果加成(self, 类型: str, x: float) -> None:
        # 所有 消耗无色 不消耗无色  (觉醒技能默认除外)
        self.__指令效果[类型] = self.__指令效果.get(类型, 1.0) * (1 + x)

    def 指令技攻加成(self, x: float, min=1, max=100, exc=[],excName = []) -> None:
        count = 0
        for i in self.技能栏:
            if i.所在等级 >= min and i.所在等级 <= max and i.所在等级 not in exc and i.手搓 == True and i.名称 not in excName:
                count +=1
                if i.是否有伤害 == 1:
                    i.倍率 *= (1 + x * self.技能伤害增加增幅)
                if i.名称 == '鬼连斩':
                    self.get_skill_by_name(
                        "鬼连斩：极").额外加成 /= (1 + x * self.技能伤害增加增幅)
        return count

    def MP消耗量加成(self, x: float) -> None:
        self.__MP消耗量 += x

    def 攻击强化加成(self, x: float) -> None:
        self.__攻击强化 += x

    def 百分比攻击强化加成(self, x: float) -> None:
        self.__百分比攻击强化 += x
        super().百分比攻击强化加成(x)

    def buff量加成(self, x: float) -> None:
        self.__buff量 += x

    def 辅助属性加成(self, buff固定力智=0, buff百分比力智=0.0, buff固定三攻=0, buff百分比三攻=0.0, 觉醒固定力智=0, 觉醒百分比力智=0.0, buff量=0, 百分比buff量=0.0,觉醒百分比力智Total=0.0):
        self.__buff固定力智 += buff固定力智
        self.__buff百分比力智 *= 1.0 + buff百分比力智
        self.__buff固定三攻 += buff固定三攻
        self.__buff百分比三攻 *= 1.0 + buff百分比三攻
        self.__觉醒固定力智 += 觉醒固定力智
        self.__觉醒百分比力智 *= 1.0 + 觉醒百分比力智
        self.__觉醒百分比力智Total *= 1.0 + 觉醒百分比力智Total
        self.__buff量 += buff量
        self.__百分比buff量 += 百分比buff量

        super().辅助属性加成(buff固定力智, buff百分比力智, buff固定三攻,
                       buff百分比三攻, 觉醒固定力智, 觉醒百分比力智, buff量, 百分比buff量)

    def 附加伤害加成(self, x: float, 辟邪玉加成=1) -> None:
        self.__附加伤害 += self.附加伤害增加增幅 * x if 辟邪玉加成 == 1 else x

    def 持续伤害加成(self, x: float) -> None:
        self.__持续伤害 += x

    def 属性附加加成(self, x: float) -> None:
        self.__属性附加 += self.属性附加伤害增加增幅 * x

    def 技能攻击力加成(self, x: float, 辟邪玉加成=1, 适用累加=1, part='', show=True) -> None:
        if x != 0:
            self.技攻列表[part] = self.技攻列表.get(part, []) + [x]
        last = 0
        if 辟邪玉加成 == 1:
            if 适用累加 == 0:
                last = self.技能伤害增加增幅 * x
                # self.技能攻击力 *= 1 + self.技能伤害增加增幅 * x
            else:
                if self.技能攻击力累加 > 2:  # 累计已经大于2不再加成
                    # self.技能攻击力 *= 1 + x
                    last = x
                elif self.技能攻击力累加 + x > 2:  # 此次累计导致大于2，一部分加成，一部分不加成
                    overflow = self.技能攻击力累加 + x - 2  # 溢出部分
                    # self.技能攻击力 *= 1 + self.技能伤害增加增幅 * (x - overflow) + overflow
                    last = self.技能伤害增加增幅 * (x - overflow) + overflow
                else:  # 累计后仍小于等于2
                    # self.技能攻击力 *= 1 + self.技能伤害增加增幅 * x
                    last = self.技能伤害增加增幅 * x
                self.技能攻击力累加 += x  # 累计计算
        else:
            last = x
            # self.技能攻击力 *= 1 + x
        self.技能攻击力 *= 1 + last
        self.__面板技能攻击力 *= 1 + (last if show else 0)
        # print(self.技攻列表)
        super().技能攻击力加成(x=x)

    def 暴击伤害加成(self, x: float, 辟邪玉加成=1) -> None:
        self.__暴击伤害 += self.暴击伤害增加增幅 * x if 辟邪玉加成 == 1 else x

    def 伤害增加加成(self, x: float, 辟邪玉加成=1) -> None:
        self.__伤害增加 += self.伤害增加增幅 * x if 辟邪玉加成 == 1 else x

    def 最终伤害加成(self, x: float, 辟邪玉加成=1) -> None:
        self.__最终伤害 += self.最终伤害增加增幅 * x if 辟邪玉加成 == 1 else x

    def 百分比力智加成(self, x: float, 辟邪玉加成=1) -> None:
        self.__百分比力智 += self.力量智力增加增幅 * x if 辟邪玉加成 == 1 else x

    def 百分比三攻加成(self, x: float, 辟邪玉加成=1) -> None:
        self.__百分比三攻 += self.物理魔法攻击力增加增幅 * x if 辟邪玉加成 == 1 else x

    def 火属性强化加成(self, x: float, 辟邪玉加成=1, mode=0) -> None:
        if mode == 0:
            self.__火属性强化 += self.所有属性强化增幅 * x if 辟邪玉加成 == 1 else x
        else:
            self.__火属性强化 += int(self.所有属性强化增幅 * x)

    def 冰属性强化加成(self, x: float, 辟邪玉加成=1, mode=0) -> None:
        if mode == 0:
            self.__冰属性强化 += self.所有属性强化增幅 * x if 辟邪玉加成 == 1 else x
        else:
            self.__冰属性强化 += int(self.所有属性强化增幅 * x)

    def 光属性强化加成(self, x: float, 辟邪玉加成=1, mode=0) -> None:
        if mode == 0:
            self.__光属性强化 += self.所有属性强化增幅 * x if 辟邪玉加成 == 1 else x
        else:
            self.__光属性强化 += int(self.所有属性强化增幅 * x)

    def 暗属性强化加成(self, x: float, 辟邪玉加成=1, mode=0) -> None:
        if mode == 0:
            self.__暗属性强化 += self.所有属性强化增幅 * x if 辟邪玉加成 == 1 else x
        else:
            self.__暗属性强化 += int(self.所有属性强化增幅 * x)

    def 所有属性强化加成(self, 所有属性强化: float = 0, 火属性强化: float = 0.00, 冰属性强化: float = 0.00, 光属性强化: float = 0.00, 暗属性强化: float = 0.00, 辟邪玉加成=1, mode=0) -> None:
        super().所有属性强化加成(所有属性强化, 火属性强化, 冰属性强化, 光属性强化, 暗属性强化)
        火属性强化 += 所有属性强化
        冰属性强化 += 所有属性强化
        光属性强化 += 所有属性强化
        暗属性强化 += 所有属性强化
        # if 火属性强化 > 0:
        self.火属性强化加成(火属性强化, 辟邪玉加成, mode)
        # if 冰属性强化 > 0:
        self.冰属性强化加成(冰属性强化, 辟邪玉加成, mode)
        # if 光属性强化 > 0:
        self.光属性强化加成(光属性强化, 辟邪玉加成, mode)
        # if 暗属性强化 > 0:
        self.暗属性强化加成(暗属性强化, 辟邪玉加成, mode)
        # if mode == 0:
        #     temp = self.所有属性强化增幅 * 所有属性强化 if 辟邪玉加成 == 1 else 所有属性强化
        # else:
        #     temp = int(self.所有属性强化增幅 * 所有属性强化)
        # self.__所有属性强化(temp)
        # super().属性强化加成(所有属性强化=所有属性强化)

    def 火属性抗性加成(self, x: int) -> None:
        self.__火属性抗性 += x

    def 冰属性抗性加成(self, x: int) -> None:
        self.__冰属性抗性 += x

    def 光属性抗性加成(self, x: int) -> None:
        self.__光属性抗性 += x

    def 暗属性抗性加成(self, x: int) -> None:
        self.__暗属性抗性 += x

    def 所有属性抗性加成(self, x: int) -> None:
        self.火属性抗性加成(x)
        self.冰属性抗性加成(x)
        self.光属性抗性加成(x)
        self.暗属性抗性加成(x)

    def 攻击速度增加(self, x: float, part: str = '') -> None:
        if part != '武器' and part != '特性':
            self.__攻击速度 += x
        else:
            self.__攻击速度_其他 += x

    def 攻击速度(self) -> float:
        return self.__攻击速度

    def 移动速度增加(self, x: float) -> None:
        self.__移动速度 += x

    def 施放速度增加(self, x: float) -> None:
        self.__施放速度 += x

    def 所有速度增加(self, x: float, part: str = '') -> None:
        if part != '武器' and part != '特性':
            self.__攻击速度 += x
        else:
            self.__攻击速度_其他 += x
        self.__移动速度 += x
        self.__施放速度 += x

    def 命中率增加(self, x: float) -> None:
        self.__命中率 += x

    def 回避率增加(self, x: float) -> None:
        self.__回避率 += x

    def 物理暴击率增加(self, x: float) -> None:
        self.__物理暴击率 += x

    def 魔法暴击率增加(self, x: float) -> None:
        self.__魔法暴击率 += x

    def 暴击率增加(self, x: float) -> None:
        self.物理暴击率增加(x)
        self.魔法暴击率增加(x)

    def buff技能等级加成(self, LV: int, lv: int) -> None:
        # LV级 buff技能等级 + lv
        pass

    def 特殊主动等级加成(self, Lv: int, lv: int) -> None:
        for i in self.技能栏:
            if i.所在等级 == Lv and i.是否主动 == 1 and i.名称 not in ["念兽：龙虎啸", "风雷啸", "圣灵符文", "神圣之光"]:
                i.等级加成(lv, char=self)

    def 技能获取(self, min: int, max: int, exc=[]) -> None:
        temp = []
        for i in self.技能栏:
            if i.所在等级 >= min and i.所在等级 <= max and i.是否主动 == 1 and i.名称 not in exc:
                temp.append(i.名称)
        return temp

    def 技能等级加成(self, 加成类型: str, min: int, max: int, lv: int, exc=[],excName=[]) -> None:
        for i in self.技能栏:
            if i.所在等级 >= min and i.所在等级 <= max and i.所在等级 not in exc  and i.名称 not in excName:
                if 加成类型 == '所有':
                    i.等级加成(lv, char=self)
                else:
                    if (i.是否主动 == 1) == (加成类型 == '主动'):
                        i.等级加成(lv, char=self)

        super().技能等级加成(加成类型, min, max, lv, exc)

    def 技能冷却缩减(self, min: int, max: int, x: float, exc=[],excName=[]) -> None:
        if min == 1 and max == 100:
            self.冷却缩减 *= (1-x)
        for i in self.技能栏:
            if i.所在等级 >= min and i.所在等级 <= max and i.所在等级 not in exc  and i.名称 not in excName:
                if i.是否有伤害 == 1:
                    i.CDR *= (1 - x)

    def 无色技能加成(self,cost=0,x=0,min=1,max=100):
        # 不消耗无色的技能加成
        if cost == 0:
            for skill in self.技能队列:
                if not (min == 1 and max == 100):
                    lv = self.get_skill_by_name(skill['名称']).所在等级
                    if lv < min or lv > max:
                        continue
                if skill['名称'] == '神罚之锤' and self.实际名称 == 'crusader_male_carry':
                    skill["倍率"] *= 1 + x * self.get_skill_by_name("神罚之锤").非无色占比()
                elif skill["无色消耗"] == 0  and skill['名称'] !='鬼连斩：极':
                    skill["倍率"] *= 1 + x
            pass
        if cost > 0:
            for skill in self.技能队列:
                if not (min == 1 and max == 100):
                    lv = self.get_skill_by_name(skill['名称']).所在等级
                    if lv < min or lv > max:
                        continue
                if skill['名称'] == '神罚之锤' and self.实际名称 == 'crusader_male_carry':
                    skill["倍率"] *= 1 + x * self.get_skill_by_name("神罚之锤").无色占比()
                elif skill["无色消耗"] >= cost:
                    skill["倍率"] *= 1 + x
            pass



    def 加算冷却缩减(self, x: float) -> None:
        self.__加算冷却缩减 += x

    def 技能恢复加成(self, min: int, max: int, x: float, exc=[],excName=[]) -> None:
        if min == 1 and max == 100:
            self.冷却恢复 += x
        for i in self.技能栏:
            if i.所在等级 >= min and i.所在等级 <= max and i.所在等级 not in exc  and i.名称 not in excName:
                if i.是否有伤害 == 1:
                    i.恢复 += x

    def 技能倍率加成(self, min: int, max: int, x: float, exc=[], type="all",excName=[]) -> None:
        for i in self.技能栏:
            if i.所在等级 >= min and i.所在等级 <= max and i.所在等级 not in exc and i.名称 not in excName:
                if i.是否有伤害 == 1:
                    if type == "all" or (type == "active" and i.是否主动 == 1):
                        i.倍率 *= (1 + x * self.技能伤害增加增幅)

    def 单技能加成(self, 名称: str, 倍率=1.0, CD=1.0, lv=0) -> None:
        i = self.get_skill_by_name(名称)
        i.等级加成(lv, char=self)
        if i.是否有伤害 == 1:
            i.倍率 *= 倍率
            i.CDR *= CD

    def __所有属性强化(self, x: float) -> None:
        self.__火属性强化 += x
        self.__冰属性强化 += x
        self.__光属性强化 += x
        self.__暗属性强化 += x

    def 斗神宠物加成(self, x: float) -> None:
        self.斗神宠物 += x

    # endregion

    # region 面板相关函数

    # 基础力量智力(站街力量智力)
    def 站街力量(self) -> int:
        return int(self.__力量)

    def 站街智力(self) -> int:
        return int(self.__智力)

    def MP消耗倍率(self) -> float:
        return self.__MP消耗量

    def 火属性强化(self) -> float:
        if self.check_fun_by_id(20045):
            return max([self.__火属性强化, self.__冰属性强化, self.__光属性强化, self.__暗属性强化])
        return self.__火属性强化

    def 冰属性强化(self) -> float:
        if self.check_fun_by_id(20045):
            return max([self.__火属性强化, self.__冰属性强化, self.__光属性强化, self.__暗属性强化])
        return self.__冰属性强化

    def 光属性强化(self) -> float:
        if self.check_fun_by_id(20045):
            return max([self.__火属性强化, self.__冰属性强化, self.__光属性强化, self.__暗属性强化])
        return self.__光属性强化

    def 暗属性强化(self) -> float:
        if self.check_fun_by_id(20045):
            return max([self.__火属性强化, self.__冰属性强化, self.__光属性强化, self.__暗属性强化])
        return self.__暗属性强化

    def 火属性抗性(self) -> float:
        return int(self.__火属性抗性 * self.属强抗性倍率)

    def 冰属性抗性(self) -> float:
        return int(self.__冰属性抗性 * self.属强抗性倍率)

    def 光属性抗性(self) -> float:
        return int(self.__光属性抗性 * self.属强抗性倍率)

    def 暗属性抗性(self) -> float:
        return int(self.__暗属性抗性 * self.属强抗性倍率)

    def 被动力智系数(self) -> float:
        return 0
    # 新词条计算的力量智力

    def 基础面板力量(self) -> float:
        return ((self.__力量 + int((self.__力量 - self.__基础力量) * self.系统奶系数 + self.系统奶基数)) + self.__进图力量)*(1+self.被动力智系数())

    def 基础面板智力(self) -> float:
        return ((self.__智力 + int((self.__智力 - self.__基础智力) * self.系统奶系数 + self.系统奶基数)) + self.__进图智力)*(1+self.被动力智系数())

    # 旧词条计算的力量智力(图内力量智力)

    def 面板力量(self) -> float:
        return (self.基础面板力量()) * (1 + self.__百分比力智)

    def 面板智力(self) -> float:
        return (self.基础面板智力()) * (1 + self.__百分比力智)

    # 站街生效的技能三攻倍率

    def 站街物理攻击力倍率(self) -> float:
        站街物理攻击倍率 = 1.0
        for i in self.技能栏:
            if hasattr(i, '物理攻击力倍率'):
                倍率 = i.物理攻击力倍率(self.武器类型)
                if 倍率 != 1 and 倍率 is not None:
                    站街物理攻击倍率 *= 倍率
        return 站街物理攻击倍率

    def 站街魔法攻击力倍率(self) -> float:
        站街魔法攻击倍率 = 1.0
        for i in self.技能栏:
            if hasattr(i, '魔法攻击力倍率'):
                倍率 = i.魔法攻击力倍率(self.武器类型)
                if 倍率 != 1 and 倍率 is not None:
                    站街魔法攻击倍率 *= 倍率
        return 站街魔法攻击倍率

    def 站街独立攻击力倍率(self) -> float:
        站街独立攻击倍率 = 1.0
        for i in self.技能栏:
            if hasattr(i, '独立攻击力倍率'):
                倍率 = i.独立攻击力倍率(self.武器类型)
                if 倍率 != 1 and 倍率 is not None:
                    站街独立攻击倍率 *= 倍率
        return 站街独立攻击倍率

    def 进图物理攻击力倍率(self) -> float:
        进图物理攻击倍率 = 1.0
        for i in self.技能栏:
            if hasattr(i, '物理攻击力倍率进图'):
                倍率 = i.物理攻击力倍率进图(self.武器类型)
                if 倍率 != 1 and 倍率 is not None:
                    进图物理攻击倍率 *= 倍率
        return 进图物理攻击倍率

    def 进图魔法攻击力倍率(self) -> float:
        进图魔法攻击倍率 = 1.0
        for i in self.技能栏:
            if hasattr(i, '魔法攻击力倍率进图'):
                倍率 = i.魔法攻击力倍率进图(self.武器类型)
                if 倍率 != 1 and 倍率 is not None:
                    进图魔法攻击倍率 *= 倍率
        return 进图魔法攻击倍率

    def 进图独立攻击力倍率(self) -> float:
        进图独立攻击倍率 = 1.0
        for i in self.技能栏:
            if hasattr(i, '独立攻击力倍率进图'):
                倍率 = i.独立攻击力倍率进图(self.武器类型)
                if 倍率 != 1 and 倍率 is not None:
                    进图独立攻击倍率 *= 倍率
        return 进图独立攻击倍率

    # 站街三攻

    def 站街物理攻击力(self) -> float:
        return self.__物理攻击力 * self.站街物理攻击力倍率()

    def 站街魔法攻击力(self) -> float:
        return self.__魔法攻击力 * self.站街魔法攻击力倍率()

    def 站街独立攻击力(self) -> float:
        return self.__独立攻击力 * self.站街独立攻击力倍率()

    # 新词条计算的三攻(旧词条需要额外乘百分比三攻)

    def 基础面板物理攻击力(self) -> float:
        面板物理攻击 = self.__物理攻击力 + int(self.__进图三攻)
        for i in self.技能栏:
            面板物理攻击 *= i.物理攻击力倍率进图(self.武器类型)
        return 面板物理攻击 * self.站街物理攻击力倍率()

    def 基础面板魔法攻击力(self) -> float:
        面板魔法攻击 = self.__魔法攻击力 + int(self.__进图三攻)
        for i in self.技能栏:
            面板魔法攻击 *= i.魔法攻击力倍率进图(self.武器类型)
        return 面板魔法攻击 * self.站街魔法攻击力倍率()

    def 基础面板独立攻击力(self) -> float:
        面板独立攻击 = self.__独立攻击力 + int(self.__进图三攻)
        for i in self.技能栏:
            面板独立攻击 *= i.独立攻击力倍率进图(self.武器类型)
        return 面板独立攻击 * self.站街独立攻击力倍率()

    # 图内显示的三攻(不参与伤害计算)

    def 面板物理攻击力(self) -> float:
        面板物理攻击 = self.基础面板物理攻击力() * (1 + self.__百分比三攻) * (self.斗神宠物加成)
        return 面板物理攻击

    def 面板魔法攻击力(self) -> float:
        面板魔法攻击 = self.基础面板魔法攻击力() * (1 + self.__百分比三攻) * (self.斗神宠物加成)
        return 面板魔法攻击

    def 面板独立攻击力(self) -> float:
        面板独立攻击 = self.基础面板独立攻击力() * (1 + self.__百分比三攻)
        return 面板独立攻击
    # endregion

    # region 其它函数
    #     def get_skill_by_name(self, name) -> 技能 | 主动技能 | 被动技能:

    def 部位是否穿戴(self, part):
        if self.部位装备.get(part, None) == None and part not in ['光环', '武器装扮', '皮肤', '宠物装备-红', '宠物装备-绿', '宠物装备-蓝', '快捷装备']:
            return False
        else:
            return True

    def get_skill_by_name(self, name) -> Union[技能, 主动技能, 被动技能]:
        return self.技能栏[self.技能序号.get(name, 0)]

    def 已穿戴神话(self):
        for i in self.装备栏:
            temp = get_equ(self.equVersion).get_equ_by_id(i)
            if temp.品质 == '神话':
                return True
        return False

    def 传说词条等级之和(self):
        total = 0
        for i in self.装备栏:
            temp = get_equ(self.equVersion).get_equ_by_id(i)
            if temp.等级 == 105 and temp.部位 not in ['称号', '宠物'] and temp.品质 == '传说':
                total += sum(self.词条等级.get(temp.部位, [0]))
        return total

    def 已传说装备数目(self):
        count = 0
        for i in self.装备栏:
            temp = get_equ(self.equVersion).get_equ_by_id(i)
            if temp.等级 == 105 and temp.部位 not in ['称号', '宠物'] and temp.品质 == '传说':
                count += 1
        return count

    def 穿戴低于105(self):
        for i in self.装备栏:
            temp = get_equ(self.equVersion).get_equ_by_id(i)
            if temp.等级 < 105 and temp.部位 not in ['称号', '宠物']:
                return True
        return False

    def 获取强化等级(self, part=[]):
        num = 0
        temp = part
        if len(temp) == 0:
            temp += 部位列表
        for i in temp:
            num += self.打造详情.get(i, {}).get('cursed_number', 0)
        return num

    def 获取改造等级(self, part=[]):
        num = 0
        temp = part
        if len(temp) == 0:
            temp += 部位列表
        for i in temp:
            num += self.打造详情.get(i, {}).get('wisdom_number', 0)
        return num
    # endregion

    # 打造设置

    def __打造设置(self, setinfo):
        self.打造详情 = setinfo
        for i in 部位列表 + ('称号', '宠物', '光环', '武器装扮', '皮肤', '宠物装备-红', '宠物装备-绿', '宠物装备-蓝', '快捷装备'):
            from core.equipment.enchanting import get_encfunc_by_id
            id = setinfo.get(i, {}).get('enchanting', 0)
            self.部位附魔[i] = get_encfunc_by_id(id)

    def 技能队列设置(self, setinfo):
        self.技能队列 = []
        for item in setinfo:
            self.技能队列.append({
                '名称': item['name'],
                '无色消耗': self.get_skill_by_name(item['name']).无色消耗,
                '倍率': 1.0,
                '等级变化': 0,
                'CDR': 1.0,
                '恢复': 0,
                '形态': item.get('mode', '')
            })

    def __药剂设置(self, setinfo):
        self.药剂 = setinfo

    def __怪物信息设置(self, id):
        from core.basic.monster import get_monster_data
        data = get_monster_data(str(id))
        self.防御输入 = data["防御"]
        self.火抗输入 = data["火抗"]
        self.冰抗输入 = data["冰抗"]
        self.光抗输入 = data["光抗"]
        self.暗抗输入 = data["暗抗"]
        pass

    def __场景设置(self, id):
        from core.basic.monster import get_scene_data
        data = get_scene_data(str(id))
        self.系统奶系数 = data["系统奶系数"]
        self.系统奶基数 = data["系统奶基数"]
        self.防御系数 = data["防御系数"]
        pass

    # 设置技能相关参数
    def __skill_set(self, setinfo):
        for i in setinfo:
            k = self.get_skill_by_name(i['name'])
            k.等级 = i['level']
            k.TP等级 = i['tp']
            k.手搓 = i['direct']
            k.手搓指令数 = i['directNumber']
            k.count = i['count']

    # 设置装备选项参数
    def __equ_chose_set(self, setinfo):
        get_equ(self.equVersion).set_func_chose(setinfo)
        # for i in setinfo:
        #    equ.set_func_chose({i['id']: i['select']})

    def hotkey_set(self, setinfo):
        self.hotkey = setinfo

    def __set_char(self, info):
        self.类型 = info['carry_type'] if self.类型 != '辅助' else self.类型
        try:
            self.buff = info['buff_ratio'] / 100 + 1
        except:
            raise ResponseException("请在技能页设置buff倍率")
        self.护石栏 = info['talisman_set']
        self.符文 = info['rune_set']

        pass

    # 设置穿戴的装备

    def __穿戴装备(self, idlist):
        self.装备栏 = []
        self.部位装备 = {}
        idlist = sorted(idlist)
        for i in idlist:
            装备 = get_equ(self.equVersion).get_equ_by_id(i)
            self.部位装备.update({装备.部位: i})
        for k in self.部位装备.keys():
            self.装备栏.append(self.部位装备[k])

    def __穿戴装扮(self, info):
        self.装扮栏 = {}
        self.装扮选项 = {}
        for i in info:
            self.装扮栏[i] = info[i].get('id', 0)
            self.装扮选项[i] = info[i].get('option', 0)
        # print(len(self.装扮栏))

    # region 伤害计算相关函数
    def __计算前预处理(self):
        # 防止中途变更影响其他计算
        self.__equ_chose_set(self.trigger_set)
        self.设置觉醒技能()
        self.职业特殊设置()
        self.__辟邪玉计算()
        self.护石计算()
        self.符文计算()
        self.装备属性计算()
        self.skills_passive = {}
        for i in self.技能栏:
            self.skills_passive[i.名称] = {
                "info": [],
                "lv": i.等级
            }
        self.职业特殊计算()
        if self.类型 != '辅助':
            self.CD倍率计算()
            self.加算冷却计算()
            self.被动倍率计算()
            self.伤害指数计算()

    def 适用数值计算(self):
        进图智力 = 0
        进图体力 = 0
        进图精神 = 0
        for skill in self.技能栏:
            if skill.是否启用:
                结算 = skill.结算统计(self)
                if skill.站街生效:
                    self.__智力 += 结算[2]
                    self.__体力 += 结算[3]
                    self.__精神 += 结算[4]
                else:
                    进图智力 += 结算[2]
                    进图体力 += 结算[3]
                    进图精神 += 结算[4]

        进图 = 0
        BUFF补正 = 0

        if self.适用属性 == '体力':
            进图 = self.__体力 + 进图体力
            BUFF补正 = self.__BUFF补正体力
        elif self.适用属性 == '精神':
            进图 = self.__精神 + 进图精神
            BUFF补正 = self.__BUFF补正精神
        else:
            进图 = self.__智力 + 进图智力
            BUFF补正 = self.__BUFF补正智力

        awake = self.get_skill_by_name('一次觉醒')
        buff = self.get_skill_by_name('BUFF')

        awake.适用数值 = 进图
        awake.一觉力智 = self.__觉醒固定力智
        awake.一觉力智per = self.__觉醒百分比力智
        awake.一觉力智perTotal = self.__觉醒百分比力智Total

        buff.适用数值 = 进图 + BUFF补正
        buff.BUFF力智per = self.__buff百分比力智
        buff.BUFF力智 = self.__buff固定力智
        buff.BUFF三攻per = self.__buff百分比三攻
        buff.BUFF三攻 = self.__buff固定三攻

        self.适用数值 = 进图
        # print('copaosee:', self.适用数值, [
        #       self.__智力, self.__体力, self.__精神], 进图, BUFF补正)

    def 站街系数(self):
        if self.适用属性 == '体力':
            return self.__体力
        elif self.适用属性 == '精神':
            return self.__精神
        return self.__智力

    def 提升率计算(self, 总数据):

        力智合计 = 0
        三攻合计 = 0

        for i in 总数据:
            力智合计 += i[0]
            三攻合计 += i[1]

        x1 = (
            (self.辅助对象力智 +
             (self.辅助对象力智 - 950) * self.系统奶系数 + self.系统奶基数) / 250 + 1) * self.辅助对象三攻

        x2 = ((self.辅助对象力智 +
               (self.辅助对象力智 - 950) * self.系统奶系数 + self.系统奶基数 + 力智合计) / 250 +
              1) * (self.辅助对象三攻 + 三攻合计)
        return [x2 / x1 * 100 * self.被动增伤倍率, int(self.站街系数()), 力智合计, 三攻合计]

    def BUFF量(self):
        return self.__buff量 * (1 + self.__百分比buff量)

    def 辅助计算(self):
        self.适用数值计算()
        data = {}
        data['无色消耗'] = 0

        skills = {}

        values = []

        for i in self.技能栏:
            rs = i.结算统计(self)[:2]
            cd = "-" if not i.是否主动 else i.等效CD()
            cd_p = "-" if not i.是否主动 else round(100 - i.等效CD() / i.CD*100,2)
            k = {}
            k['name'] = i.名称
            k['data'] = rs
            if hasattr(i, '适用数值'):
                k['apply_status'] = i.适用数值
            if sum(rs) > 0 or cd != '-':
                values.append(rs)
                skills[i.名称] = {'name': i.名称, 'level': i.等级, 'data': rs,'cd':cd,'cd_p':cd_p}

        结果 = self.提升率计算(values)

        data['total_data'] = 结果[0]
        data['buffer_addition'] = 结果
        data['skills'] = skills

        return data

    def 结果计算(self):
        if self.类型 == '辅助':
            return self.辅助计算()
        else:
            return self.伤害计算()

    def 职业特殊计算(self):
        pass

    def 伤害计算技能特殊处理(self, skill: 技能):
        pass

    def 伤害计算(self):
        data = {}
        total_data = 0

        skill_dict = {}
        # 无色消耗 = 0
        CDR = []

        for i in self.技能队列:
            k = self.get_skill_by_name(i['名称'])
            if k.是否有伤害 == 1:
                temp = skill_dict.get(k.名称, {})
                self.伤害计算技能特殊处理(k)
                if k.名称 not in data.keys():
                    temp['rate'] = k.被动倍率
                    if temp.get("cd", 0) > 0:
                        temp['cd'] = (k.等效CD(
                            武器类型=self.武器类型, 输出类型=self.类型, 额外CDR=i['CDR'], 额外恢复=i['恢复']) + temp['cd']*temp['count']) / (temp['count']+1)
                    else:
                        temp['cd'] = k.等效CD(
                            武器类型=self.武器类型, 输出类型=self.类型, 额外CDR=i['CDR'], 额外恢复=i['恢复'])
                    temp['mp'] = k.MP消耗(
                        武器类型=self.武器类型, 输出类型=self.类型, 额外倍率=self.__MP消耗量, char=self)
                    temp['atk_rate'] = k.等效百分比(
                        武器类型=self.武器类型, 形态=i['形态'], char=self)
                    temp['cosume_cube_frag'] = k.无色消耗
                    temp['level'] = k.等级
                    temp['cd_o'] = k.CD[k.等级] if isinstance(
                        k.CD, list) else k.CD
                    temp['cd_unsave'] = (k.恢复 + i['恢复']) if temp.get('cd_unsave',1) == 1 else (temp.get('cd_unsave',1) + k.恢复 + i['恢复'])/2
                直伤 = k.等效百分比(
                    武器类型=self.武器类型, 额外等级=i['等级变化'], 额外倍率=i['倍率'], 伤害类型="直伤", 形态=i['形态'], char=self)

                # 直伤处理：直伤伤害*比例*系数
                damage = 直伤 * self.伤害指数 * k.被动倍率 * \
                    (self.伤害比例.get("直伤", 0.0)) / 100
                for item in ['中毒', '灼伤', '感电', '出血']:
                    cur = item
                    pa = ''
                    if item == '中毒':
                        pa = 'zd_rate'
                    if item == '出血':
                        pa = 'cx_rate'
                    if item == '感电':
                        pa = 'gd_rate'
                    if item == '灼伤':
                        pa = 'zs_rate'
                    if item == '灼伤' and '灼伤' in get_global_data("state_type", self.equVersion) and ('冰冻' in get_global_data("get_state_type", self.equVersion) or ('冰冻' in get_global_data("state_type", self.equVersion) and self.check_equ_by_name("永眠前的准备"))):
                        pa = 'zs_bd_rate'
                        cur = '灼伤破冰'
                    保有率 = 0
                    异常基础加成 = 1.0
                    异常结算加成 = 1.0
                    装备加成异常结算 = 1.0
                    if pa == 'zs_bd_rate':
                        保有率 = self.异常保有率计算(pa,cur)
                        异常基础加成 = 1.0
                        异常结算加成 = self.异常基础加成['灼伤破冰']
                        装备加成异常结算 = self.异常结算加成.get(cur,1.0)
                    else:
                        保有率 = self.异常保有率计算(pa,cur)
                        # 叠层处理
                        异常基础加成 = 1+ (self.异常基础加成.get(cur,1.0)-1) * get_global_data(pa,self.equVersion,1.0)
                        异常结算加成 = 1.0
                        装备加成异常结算 = self.异常结算加成.get(cur,1.0)
                    系数 = self.伤害系数.get(item, 0.0) * ( (1-保有率) * 异常基础加成 + 保有率 * 异常基础加成 * 异常结算加成 * 装备加成异常结算)
                    # 直伤转换的异常处理：直伤伤害*异常比例*异常系数
                    damage += 直伤 * self.伤害指数 * k.被动倍率 * \
                        (self.伤害比例.get(item, 0.0) * 系数) / 100
                    # 异常伤害处理：异常伤害*异常系数
                    damage += k.等效百分比(
                        武器类型=self.武器类型,  额外等级=i['等级变化'], 额外倍率=i['倍率'], 伤害类型=item, 形态=i['形态'], char=self) * self.伤害指数 * k.被动倍率*系数 / 100
                total_data += damage
                temp['name'] = k.名称
                temp['damage'] = temp.get('damage', 0) + damage
                temp['count'] = temp.get('count', 0) + 1
                skill_dict[k.名称] = temp
                # if k.名称 not in ['爆裂弹', '杀意波动', '万毒噬心诀', '神罚之锤']:
                #     无色消耗 += i['无色消耗']
                # if k.CD > 1:
                #     CDR.append(
                #         (k.名称, round(1 - temp.get('cd', 0)/temp.get('cd_o', 0), 4)))
        data['skills_passive'] = {}
        for i in self.技能栏:
            if i.关联技能 != ['无'] or i.冷却关联技能 != ['无']:
                temp = {}
                temp['lv'] = i.等级
                temp['name'] = i.名称
                data['skills_passive'][i.名称] = temp
            if skill_dict.get(i.名称, None) != None:
                if (i.CD[k.等级] if isinstance(i.CD, list) else i.CD) > 1:
                    temp = skill_dict.get(i.名称, {})
                    if temp.get('cd_o', 0) == 0:
                        CDR.append((i.名称, 0, 0))
                    else:
                        CDR.append(
                            (i.名称, round(1 - temp.get('cd', 0)/temp.get('cd_o', 0), 4), temp.get('cd', 0)))
                pass
        data['skills'] = skill_dict
        data['total_data'] = total_data
        # data['无色消耗'] = 无色消耗
        data['CDR'] = CDR
        # dps = 0
        # for temp in data['skills']:
        #     skill = data['skills'][temp]
        #     try:
        #         dps += (skill['damage']/skill['count'])/skill['cd']
        #     except:
        #         pass
        # data['dps'] = dps
        return data

    def 装备属性计算(self):
        self.套装统计()
        self.装备基础()
        self.__时装基础()
        self.__附魔计算()
        self.__杂项计算()
        self.__徽章计算()
        if self.类型 != '辅助':
            self.药剂计算()
        self.__装备词条计算()

    def __时装基础(self):
        时装品级列表 = {}
        for 部位 in self.装扮栏:
            id = int(self.装扮栏[部位])
            时装 = 装扮集合[id]
            时装.效果(角色=self, 选项=self.装扮选项[部位])
            时装品级列表[时装.套装] = 时装品级列表.get(时装.套装, 0) + 1

        套装集合: List[装扮套装] = []

        for 套装 in 装扮套装集合:
            数量 = 时装品级列表.get(套装.名称, 0)
            if 数量 > 0:
                if 数量 >= 套装.所需数量:
                    查找 = len([i for i in 套装集合 if hasattr(i, '兼容于') and i.兼容于 ==
                              套装.名称 and i.所需数量 == 套装.所需数量])
                    if 查找 == 0:
                        套装集合.append(套装)
                else:
                    if hasattr(套装, '兼容于') and 套装.兼容于 is not None:
                        数量 += 时装品级列表.get(套装.兼容于, 0)
                        时装品级列表[套装.兼容于] = 数量
                        时装品级列表.pop(套装.名称)
        for 套装 in 套装集合:
            套装.效果(self)

        pass

    def __辟邪玉计算(self):
        if 'jade' not in self.打造详情.keys():
            return
        setinfo = self.打造详情['jade']
        for i in ['jade_First', 'jade_Second', 'jade_Third', 'jade_Fourth']:
            if i + '_type' in setinfo.keys():
                try:
                    id = setinfo[i + '_type']
                    value = float(setinfo[i + '_value'])
                except:
                    id = 0
                    value = 0
                from core.equipment.jade import get_jadefunc_by_id
                func = get_jadefunc_by_id(id)
                func(self, value=value)
                # 打印相关函数和效果

    def 护石计算(self):
        for item in self.护石栏:
            try:
                if not item is None and item != '' and item != '无':
                    self.get_skill_by_name(item).装备护石(char=self)
            except:
                pass

    def 符文计算(self):
        for item in self.符文:
            if not item is None and item != '':
                skill_name: str = item[0:-1]
                type = item[-1]
                skill = self.get_skill_by_name(skill_name)

                if skill is not None:
                    # 紫
                    if type == "1":
                        skill.倍率 *= 1.04
                        # 红
                    if type == "2":
                        skill.倍率 *= 1.06
                        skill.CDR *= 1.04
                        # 绿
                    if type == "3":
                        skill.倍率 *= 0.96
                        skill.CDR *= 0.93
                        # 蓝
                    if type == "4":
                        skill.CDR *= 0.95
                else:
                    print("skill not found {skill_name}".format(skill_name))
            pass

    def __杂项计算(self, mode=0):
        if 'others' not in self.打造详情.keys():
            return
        setinfo = self.打造详情['others']
        # 收集箱
        try:
            from core.equipment.sundry import get_sundriesfunc_by_id
            func = get_sundriesfunc_by_id(setinfo['SJX_TYPE'])
            # print(func)
            func(self, 0, False, setinfo['SJX_XY'], setinfo['SJX_SQ'])
        except:
            pass
        # 勋章
        try:
            from core.equipment.sundry import get_sundriesfunc_by_id
            func = get_sundriesfunc_by_id(setinfo['XZ_TYPE'])
            func(self, 0, False, setinfo.get("XZ_SHZ", 0),
                 setinfo.get("XZ_QH", 0), setinfo.get("XZ_GS", 0))
        except:
            pass
        # 勋章 - New
        # 老徽章选择为无 才生效
        if int(setinfo.get('XZ_TYPE', 0)) == 0:
            try:
                from core.equipment.sundry import get_sundriesfunc_by_id
                func = get_sundriesfunc_by_id(27063)
                func(self, 0, False, setinfo.get("medal_quality", 0), setinfo.get(
                    "medal_lv", 0), [setinfo.get("medal_gems_1", 0), setinfo.get("medal_gems_2", 0), setinfo.get("medal_gems_3", 0), setinfo.get("medal_gems_4", 0)],0.1)
                pass
            except:
                pass
        for i in setinfo.keys():
            if i.startswith('SJX') or i.startswith('XZ'):
                pass
            else:
                try:
                    id = setinfo[i]
                    from core.equipment.sundry import get_sundriesfunc_by_id
                    func = get_sundriesfunc_by_id(id)
                    # 站街
                    func(self)
                    # 进图
                    func(self, mode=1)
                except:
                    pass

    def __徽章计算(self):
        idlist = []
        for i in 部位列表 + ('皮肤', '光环', '武器装扮'):  # ('皮肤', '光环', '武器装扮', )
            if i in self.打造详情.keys() and self.部位是否穿戴(i):
                temp = self.打造详情[i]
                for j in ['socket_left', 'socket_right']:
                    id = temp.get(j, 0)
                    if id == 0:
                        pass
                    elif str(id).isdigit():
                        idlist.append(id)
                    else:
                        # 白金技能等级加成处理 id:技能名称
                        self.单技能加成(名称=id, lv=1)
                        self.基础属性加成(四维=8)
                        pass
        for i in idlist:
            from core.equipment.emblems import get_embfunc_by_id
            func = get_embfunc_by_id(i)
            func(self)
            # 打印相关函数和效果
            # print('{}: {}'.format(func, func(self, text=TRUE)))

    def __附魔计算(self):
        for i in self.部位附魔.keys():
            if self.部位是否穿戴(i):
                func = self.部位附魔[i]
                func(self, part=i)
                func(self, mode=1, part=i)
            # 打印相关函数和效果
            # print('{}: {}: {}'.format(i, func, func(self, text=TRUE)))

    def 装备基础(self):
        # 移除不符合版本的装备，不参与后续计算
        self.装备栏 = list(
            filter(lambda x: get_equ(self.equVersion).get_equ_by_id(x).名称 != '', self.装备栏))
        for id in self.装备栏:
            temp = get_equ(self.equVersion).get_equ_by_id(id)
            temp = get_equ(self.equVersion).get_equ_by_id(id, self.打造详情.get(temp.部位, {}).get('growth_sj', 0) > 0)
            if '甲' in temp.类型:
                self.__防具计算(temp)
            elif temp.类型 == '首饰':
                self.__首饰计算(temp)
            elif temp.类型 == '特殊装备':
                self.__特殊装备计算(temp)
            elif temp.部位 == '武器':
                self.武器计算(temp)
            elif temp.部位 in ['称号', '宠物']:
                self.__称号宠物计算(temp)
            if temp.部位 not in ['称号', '宠物']:
                self.__增幅计算(temp)
        pass

        # if temp.所属套装 != '智慧产物':
        #    return 精通计算(temp.等级, temp.品质, self.打造详情.get(部位, {}).get('cursed_number', 0), 部位)
        # else:
        #    return 精通计算(temp.等级, temp.品质, self.打造详情.get(部位, {}).get('wisdom_number', 0), 部位)

    def __防具计算(self, temp: equipment) -> None:
        self.基础属性加成(**temp.__dict__)

        部位 = temp.部位
        强化等级 = self.打造详情.get(部位, {}).get('cursed_number', 0)

        力量 = 智力 = 体力 = 精神 = 0

        if self.类型 == '辅助':
            if '智力' in self.防具精通属性:
                智力 += 辅助精通计算(110 if temp.神 else temp.等级, temp.品质, 强化等级, 部位,'智力')
            if '精神' in self.防具精通属性:
                精神 += 辅助精通计算(110 if temp.神 else temp.等级, temp.品质, 强化等级, 部位,'精神')
            if '体力' in self.防具精通属性:
                体力 += 辅助精通计算(110 if temp.神 else temp.等级, temp.品质, 强化等级, 部位,'体力')
        else:
            精通数值 = 精通计算(110 if temp.神 else temp.等级, temp.品质, 强化等级, 部位,self.防具类型)
            if '力量' in self.防具精通属性:
                力量 += 精通数值
            if '智力' in self.防具精通属性:
                智力 += 精通数值

        # if temp.等级 == 105:
        #     if self.类型 == '辅助':
        #         self.技能等级加成('主动', 30, 30, 1)
        #         self.技能等级加成('主动', 50, 50, 1)
        self.基础属性加成(力量=力量, 智力=智力, 体力=体力, 精神=精神)

    def __增幅计算(self, temp: equipment) -> None:
        if self.打造详情.get(temp.部位, {}).get('cursed_type', 1) == 1:
            x = 增幅计算(temp.等级, temp.品质, self.打造详情.get(
                temp.部位, {}).get('cursed_number', 0))
            if self.类型 == '物理百分比' or self.类型 == '物理固伤':
                self.基础属性加成(力量=x)
                self.打造[temp.部位]['增幅四维'][0] = x
            elif self.类型 == '魔法百分比' or self.类型 == '魔法固伤':
                self.基础属性加成(智力=x)
                self.打造[temp.部位]['增幅四维'][1] = x
            elif self.类型 == '辅助':
                if self.适用属性 == '体力':
                    self.基础属性加成(体力=x)
                    self.打造[temp.部位]['增幅四维'][2] = x
                elif self.适用属性 == '精神':
                    self.基础属性加成(精神=x)
                    self.打造[temp.部位]['增幅四维'][3] = x
                else:
                    self.基础属性加成(智力=x)
                    self.打造[temp.部位]['增幅四维'][1] = x
        # if self.是否增幅[i] and temp.所属套装 != '智慧产物':
        #    x = 增幅计算(temp.等级, temp.品质, self.强化等级[i])

    def __称号宠物计算(self, temp: equipment) -> None:
        self.基础属性加成(**temp.__dict__)

    def __首饰计算(self, temp: equipment) -> None:
        self.基础属性加成(**temp.__dict__)
        # if temp.等级 == 105 and self.类型 == '辅助':
        #     self.技能等级加成('主动', 30, 30, 1)
        #     self.技能等级加成('主动', 50, 50, 1)

    def __特殊装备计算(self, temp: equipment) -> None:
        self.基础属性加成(**temp.__dict__)
        # if temp.等级 == 105 and self.类型 == '辅助':
        #     self.技能等级加成('主动', 30, 30, 1)
        #     self.技能等级加成('主动', 50, 50, 1)
        #     if temp.品质 == '史诗' and temp.部位 == '魔法石':
        #         self.技能等级加成('主动', 50, 50, 1)
        # 耳环
        if temp.部位 == '耳环':
            # if temp.所属套装 != '智慧产物':
            x = 耳环计算(temp.等级, temp.品质, self.打造详情.get(
                temp.部位, {}).get('cursed_number', 0))
            self.打造['耳环']['强化攻击力'] = [x] * 3
            self.基础属性加成(三攻=x)
        # 辅助装备、魔法石
        else:
            # if temp.所属套装 != '智慧产物':
            x = 左右计算(temp.等级, temp.品质, self.打造详情.get(
                temp.部位, {}).get('cursed_number', 0))
            if self.类型 == "辅助":
                self.打造[temp.部位]['强化四维'] = [x]*4
            else:
                self.打造[temp.部位]['强化四维'] = [x]*2
            self.基础属性加成(四维=x)

    def 武器计算(self, temp: equipment) -> None:
        self.基础属性加成(**temp.__dict__)
        self.武器类型 = temp.类型
        # if temp.等级 == 105 and self.类型 == '辅助':
        #     self.技能等级加成('主动', 30, 30, 3)
        #     self.技能等级加成('主动', 50, 50, 4)
        # if temp.品质 == '史诗':
        #     self.技能等级加成('主动', 50, 50, 1)
        # if temp.所属套装 != '智慧产物':
        info = self.打造详情.get(temp.部位, {})
        物理攻击力 = 武器强化计算(temp.等级, temp.品质, info.get('cursed_number', 0), temp.类型,
                       '物理')
        魔法攻击力 = 武器强化计算(temp.等级, temp.品质, info.get('cursed_number', 0), temp.类型,
                       '魔法')
        独立攻击力 = 锻造计算(temp.等级, temp.品质, info.get('dz_number', 0))

        self.打造['武器']['强化攻击力'] = [物理攻击力, 魔法攻击力, 0]

        self.打造['武器']['锻造加成'][0] = 独立攻击力

        四维 = 0
        if self.类型 == '辅助':
            四维 = 锻造四维(temp.等级, temp.品质, info.get('dz_number', 0))
            self.打造['武器']['锻造加成'][1] = 四维

        self.基础属性加成(物理攻击力=物理攻击力, 魔法攻击力=魔法攻击力, 独立攻击力=独立攻击力, 四维=四维)

    def 职业装备特殊计算(self) -> None:
        pass

    def 药剂计算(self, rate=1.0) -> None:
        from core.equipment.consumable import get_sundriesfunc_by_id
        for item in self.药剂:
            func = get_sundriesfunc_by_id(item)
            func(self, rate=rate, mode=0)
            func(self, rate=rate, mode=1)

    def 是否升级110(self, part):
        return self.词条等级[part][0] > 80

    def 套装统计(self):
        suit = []
        self.suits = []
        equs = get_equ(self.equVersion)
        for i in 部位列表:
            equ = equs.get_equ_by_id(self.部位装备.get(i, 0))
            if len(equ.suits) < 0:
                continue
            # 星辰百变
            if len(equ.可选属性) > 0:
                if self.打造详情.get(i, {}).get('changeable', True):
                    suit += equ.suits
            else:
               suit += equ.suits
        for i in self.融合列表:
            equ = equs.get_equ_by_id(i)
            if len(equ.suits) < 0:
                continue
            suit += equ.suits
        suit_count = {}
        for i in set(suit):
            suit_count[i] = suit.count(i)
        for i in suit_count:
            suitsInfo = list(filter(lambda x:x["suit_id"] == i and x["need_num"] <= suit_count[i],equs.suit_info))
            suits = []
            compatibility = []
            for j in suitsInfo:
                suits.append(j["id"])
                compatibility += j["compatibility"]
            self.suits += list(set(suits)^set(compatibility))
        pass

    def __装备词条计算(self):
        # 攻击强化相关计算
        for i in 部位列表:
            temp = []
            equ = get_equ(self.equVersion).get_equ_by_id(self.部位装备.get(i, 0))
            if equ.品质 == "传说":
                limit = 70
                for j in ["growth_cs_first", "growth_cs_second", "growth_cs_third", "growth_cs_fourth"]:
                    temp.append(min(limit, self.打造详情.get(i, {}).get(j, 1)))
            else:
                limit = 80
                growth_sj =  self.打造详情.get(i, {}).get("growth_sj", 0)
                if growth_sj > 0:
                    temp = [80+growth_sj]*4
                else:
                    for j in ["growth_first", "growth_second", "growth_third", "growth_fourth"]:
                        temp.append(min(limit, self.打造详情.get(i, {}).get(j, 1)))
            # limit = 70 if get_equ(self.equVersion).get_equ_by_id(
            #     self.部位装备.get(i, 0)).品质 == "传说" else 80
            # for j in ["growth_first", "growth_second", "growth_third", "growth_fourth"]:
            #     temp.append(min(limit, self.打造详情.get(i, {}).get(j, 1)))
            self.词条等级[i] = temp

        武器融合词条 = self.武器融合.get(str(self.部位装备.get('武器', 0)), [])
        成长词条组合 = get_equ(self.equVersion).get_damagelist_by_idlist(
            self.装备栏, self.自定义词条, self.融合列表, 武器融合词条)

        temp_params = {}
        for 部位, 序号, atk, buff, params, _type, index in 成长词条组合:
            if _type > 0:
                等级 = self.词条等级[部位][序号]
            else:
                # 贴膜/融合
                等级 = 1
            attack = 成长词条计算(atk, 等级,self.equVersion)
            if get_equ(self.equVersion).get_equ_by_id(self.部位装备.get(部位,0)).品质 == "传说" and 等级 > 60:
                attack += 10*(等级-60)/4
            buffer = 成长词条计算(buff, 等级,self.equVersion)
            self.攻击强化加成(attack)
            self.辅助属性加成(buff量=buffer)
            # 装备打造
            if _type > 0:
                self.打造[部位]["attack"][序号] = attack
                self.打造[部位]["buffer"][序号] = buffer
                self.打造[部位]["params"][序号] = []

            temp_params[部位] = temp_params.get(部位, {})
            temp_params[部位][str(序号)] = temp_params[部位].get(str(序号), [])

            params = [] if params == None else params
            for param in params:
                param = 成长词条计算(param, 等级,self.equVersion)
                if _type > 0:
                    self.打造[部位]["params"][序号].append(param)
                temp_params[部位][str(序号)].append(param)

        # 词条效果相关计算
        for func, 部位, 序号, index, _type in get_equ(self.equVersion).get_func_list_by_idlist(self):
            if _type > 0:
                等级 = self.词条等级[部位][序号]
            # 特性
            elif _type == -2:
                等级 = self.特性等级.get(str(index),0)
            else:
                等级 = 1
            params = temp_params.get(部位, {}).get(str(序号), [])
            # print(部位, 序号, self.打造[部位]["params"][序号], index)
            params = [] if params == [None] else params
            # print(序号, params, index)
            # print(序号, params, 部位)
            res = func(self, mode=0, part=部位, lv=等级, params=params)  # 进图效果
            if res != None:
                # print(res, type(res))
                if type(res) == list:
                    for i in res:
                        self.打造[部位]["tips"].append(i)
                else:
                    self.打造[部位]["tips"].append(res)
                if 部位 not in self.tip_part:
                    self.tip_part.append(部位)

        for func, 部位, 序号, index, _type in get_equ(self.equVersion).get_func_list_by_idlist(self):
            if _type > 0:
                等级 = self.词条等级[部位][序号]
            # 特性
            elif _type == -2:
                等级 = self.特性等级.get(str(index),0)
            else:
                等级 = 1
            params = temp_params.get(部位, {}).get(str(序号), [])
            # print(部位, 序号, self.打造[部位]["params"][序号], index)
            params = [] if params == [None] else params
            # print(序号, params, index)
            # print(序号, params, 部位)
            # func(self, part=部位, lv=等级, params=params)  # 站街效果
            res = func(self, mode=1, part=部位, lv=等级, params=params)  # 进图效果
            if res != None:
                # print(res, type(res))
                if type(res) == list:
                    for i in res:
                        self.打造[部位]["tips"].append(i)
                else:
                    self.打造[部位]["tips"].append(res)
                if 部位 not in self.tip_part:
                    self.tip_part.append(部位)
            # 打印相关函数和效果
            # print('{}(lv.{}): {} {}'.format(部位, 等级, func, func(self, text=TRUE)))

    def check_fun_by_id(self, id):
        idList = get_equ(self.equVersion).get_func_list_by_idlist(self)
        return id in [index for _, _, _, index, _ in idList]

    def check_equ_by_name(self,name):
        id = get_equ(self.equVersion).get_equ_by_name(name).id
        return id > 0 and (id in self.装备栏 or id in self.融合列表)

    def check_fusion_upgrade(self,part):
        return self.打造详情.get(part, {}).get('fusion_upgrade', False)

    def 被动倍率计算(self):
        if self.__基础精通倍率 != 1:
            基础精通 = self.get_skill_by_name('基础精通')
            if 基础精通.名称 == '基础精通':
                基础精通.倍率 *= self.__基础精通倍率

        for i in self.技能栏:
            i.被动倍率 = 1
        for i in self.技能栏:
            for index in range(0, 4):
                index = "" if index == 0 else str(index)
                关联技能 = getattr(i, "关联技能"+index, ["无"])
                非关联技能 = getattr(i, "非关联技能"+index, ["无"])
                try:
                    加成倍率 = eval("i.加成倍率"+index+"(self.武器类型)")
                except:
                    加成倍率 = 1.0
                try:
                    # print(i.名称, 加成倍率, eval("i.加成描述"+index+"(self.武器类型)"))
                    if 加成倍率 != 1:
                        self.skills_passive[i.名称]['info'].append({
                            "type": "倍率",
                            "info": eval("i.加成描述"+index+"(self.武器类型)")})
                except:
                    pass
                if 关联技能 != ['无']:
                    if 关联技能 == ['所有']:
                        for j in self.技能栏:
                            if j.是否有伤害 == 1:
                                j.被动倍率 *= 加成倍率
                    else:
                        # print(self.技能序号)
                        for k in 关联技能:
                            self.技能栏[self.技能序号[k]].被动倍率 *= 加成倍率
                if 非关联技能 != ['无']:
                    if 非关联技能 == ['所有']:
                        for j in self.技能栏:
                            if j.是否有伤害 == 1:
                                j.被动倍率 /= 加成倍率
                    else:
                        for k in 非关联技能:
                            self.技能栏[self.技能序号[k]].被动倍率 /= 加成倍率

    def 加算冷却计算(self):
        for i in self.技能栏:
            if i.是否有伤害 == 1:
                i.CDR *= (1 - self.__加算冷却缩减)

    def CD倍率计算(self):
        for i in self.技能栏:
            for index in range(0, 4):
                index = "" if index == 0 else str(index)
                关联技能 = getattr(i, "冷却关联技能"+index, ["无"])
                非关联技能 = getattr(i, "非冷却关联技能"+index, ["无"])
                冷却类型 = getattr(i, "冷却类型"+index, 0)
                try:
                    加成倍率 = eval("i.CD缩减倍率"+index+"(self.武器类型)")
                except:
                    加成倍率 = 1.0
                try:
                    if 加成倍率 != 1:
                        self.skills_passive[i.名称]['info'].append({
                            "type": "CDR",
                            "info": eval(
                                "i.CD缩减描述"+index+"(self.武器类型)")
                        })
                except:
                    pass
                if 关联技能 != ['无']:
                    if 关联技能 == ['所有']:
                        for j in self.技能栏:
                            if j.是否有伤害 == 1:
                                if 冷却类型 == 0:
                                    j.CDR *= 加成倍率
                                if 冷却类型 == 1:
                                    j.CDR_O *= 加成倍率
                    else:
                        for k in 关联技能:
                            if 冷却类型 == 0:
                                self.技能栏[self.技能序号[k]].CDR *= 加成倍率
                            if 冷却类型 == 1:
                                self.技能栏[self.技能序号[k]].CDR_O *= 加成倍率
                if 非关联技能 != ['无']:
                    if 非关联技能 == ['所有']:
                        for j in self.技能栏:
                            if j.是否有伤害 == 1:
                                if 冷却类型 == 0:
                                    j.CDR /= 加成倍率
                                if 冷却类型 == 1:
                                    j.CDR_O /= 加成倍率
                    else:
                        for k in 非关联技能:
                            if 冷却类型 == 0:
                                self.技能栏[self.技能序号[k]].CDR /= 加成倍率
                            if 冷却类型 == 1:
                                self.技能栏[self.技能序号[k]].CDR_O /= 加成倍率

    def __属性倍率计算(self):
        # 火、冰、光、暗
        self.属性倍率组 = []
        self.属性倍率组.append(1.05 + 0.0045 * int(self.__火属性强化 - self.火抗输入))
        self.属性倍率组.append(1.05 + 0.0045 * int(self.__冰属性强化 - self.冰抗输入))
        self.属性倍率组.append(1.05 + 0.0045 * int(self.__光属性强化 - self.光抗输入))
        self.属性倍率组.append(1.05 + 0.0045 * int(self.__暗属性强化 - self.暗抗输入))
        self.属性倍率 = max(self.属性倍率组)

    def __面板系数计算(self, mode=1):
        if self.类型 == None:
            self.类型 = self.输出类型选项[0]
        # 基础面板 不含百分比力智和百分比三攻
        if mode == 0:
            if self.类型 == '物理百分比':
                return int((self.基础面板力量() / 250 + 1) * self.基础面板物理攻击力())
            elif self.类型 == '魔法百分比':
                return int((self.基础面板智力() / 250 + 1) * self.基础面板魔法攻击力())
            elif self.类型 == '物理固伤':
                return int((self.基础面板力量() / 250 + 1) * self.基础面板独立攻击力())
            elif self.类型 == '魔法固伤':
                return int((self.基础面板智力() / 250 + 1) * self.基础面板独立攻击力())
        # 旧版算法 不含斗神、宠物技能等
        else:
            if self.类型 == '物理百分比':
                return int((self.面板力量() / 250 + 1) * self.基础面板物理攻击力() * (1 + self.__百分比三攻))
            elif self.类型 == '魔法百分比':
                return int((self.面板智力() / 250 + 1) * self.基础面板魔法攻击力() * (1 + self.__百分比三攻))
            elif self.类型 == '物理固伤':
                return int((self.面板力量() / 250 + 1) * self.基础面板独立攻击力() * (1 + self.__百分比三攻))
            elif self.类型 == '魔法固伤':
                return int((self.面板智力() / 250 + 1) * self.基础面板独立攻击力() * (1 + self.__百分比三攻))

    def 伤害指数计算(self):

        防御 = max(self.防御输入 * self.防御系数 - self.__固定减防, 0) * (1 - self.__百分比减防)

        # 固定攻击方100级
        基准倍率 = 1.5 * self.buff * (1 - 防御 / (防御 + 200 * 100))

        self.__属性倍率计算()

        # 基础面板 不含百分比力智和百分比三攻
        基础面板 = self.__面板系数计算(mode=0)
        旧版面板 = self.__面板系数计算(mode=1)

        # 攻击强化显示改版
        新 = self.__攻击强化 * (1 + self.__百分比攻击强化) * 0.01
        # 攻击强化显示改版

        旧 = 1 + int((self.__伤害增加 + 0.00000001) * 100) / 100  # 避免出现浮点数取整BUG
        旧 *= 1 + self.__暴击伤害
        旧 *= 1 + self.__最终伤害
        旧 *= 1 + self.__持续伤害
        旧 *= 1 + self.__附加伤害 + self.__属性附加 * self.属性倍率

        self.伤害指数 = (新 * 基础面板 + 旧 * 旧版面板) * self.技能攻击力 * \
            self.属性倍率 * 基准倍率 * self.斗神宠物 * \
            (1.25 if '破招攻击' in get_global_data(
                "attack_type", self.equVersion) else 1.0)

        # 7.8日,伤害数据压缩
        self.伤害指数 /= 1000

    def 基础属性修正(self, info):
        from core.util.toNum import str_to_num
        self.攻击强化加成(str_to_num(info.get("攻击强化", 0)))
        self.buff量加成(str_to_num(info.get("BUFF量", 0)))
        self.百分比攻击强化加成(str_to_num(info.get("攻击强化百分比", 0))/100)
        self.__百分比buff量 += str_to_num(info.get("BUFF量百分比", 0))/100
        if self.类型 == '辅助':
            self.基础属性加成(四维=str_to_num(info.get("四维", 0)))
        else:
            self.基础属性加成(进图力量=str_to_num(info.get("四维", 0)), 进图智力=str_to_num(info.get("四维", 0)), 体精=str_to_num(info.get("四维", 0)),
                        三攻=str_to_num(info.get("三攻", 0)))
        self.技能攻击力加成(str_to_num(info.get("技攻", 0))/100)
        self.基础属性加成(火属性抗性=str_to_num(info.get("火抗", 0)), 光属性抗性=str_to_num(
            info.get("光抗", 0)), 冰属性抗性=str_to_num(info.get("冰抗", 0)), 暗属性抗性=str_to_num(info.get("暗抗", 0)))
        self.攻击速度增加(str_to_num(info.get("攻速", 0))/100)
        self.火属性强化加成(str_to_num(info.get("火强", 0)))
        self.光属性强化加成(str_to_num(info.get("光强", 0)))
        self.冰属性强化加成(str_to_num(info.get("冰强", 0)))
        self.暗属性强化加成(str_to_num(info.get("暗强", 0)))
        for 抗性 in ['出血', '中毒', '灼伤', '感电',  '冰冻', '减速', '眩晕', '诅咒', '失明', '石化', '睡眠', '混乱', '束缚']:
            self.异常抗性加成(抗性, str_to_num(info.get(抗性 + '抗性', 0))/100)
        self.MP消耗量加成(str_to_num(info.get("MP消耗量", 0))/100)
        self.set_eq_params(
            'skill_range', self.get_eq_params('skill_range')+str_to_num(info.get("技能范围Σ", 0))/100)
    # endregion

    def get_individuation(self, index):
        if index >= len(self.individuation):
            return 0
        else:
            return 0 if self.individuation[index] == None else self.individuation[index]

    def calc_init(self, info, equipList: List[int] = []):
        # 获取打造数据
        self.__打造设置(info.get('forge_set', {}))
        # 设置职业信息
        self.__set_char(info)

        self.__怪物信息设置(info.get("monster", 2))

        self.__场景设置(info.get("scene", 1))

        # 自定义词条部分
        self.自定义词条 = info.get('customize', {})
        #  时装设置
        self.__穿戴装扮(info.get('dress_set', {}))
        # 获取装备列表
        self.__穿戴装备(list(map(int, equipList)))
        self.技能队列设置(info.get('skill_que', []))
        # 获取技能数据
        self.__skill_set(info.get('skill_set', {}))
        # 获取装备选项数据
        self.trigger_set = info.get('trigger_set', {})
        self.__equ_chose_set(self.trigger_set)
        # 药剂设置
        self.__药剂设置(info.get('consumable_list', []))

        self.hotkey_set(info.get('hotkey_set', []))

        self.融合列表 = list(map(int, info.get("fusion_list",[])))

        self.武器融合 = info.get('merge', {})

        self.特性列表 = [int(i) for i in list(info.get("specificity",{}).keys())]

        self.特性等级 = info.get("specificity",{})

        self.individuation = info.get('individuation', [])
        self.基础属性修正(info.get("corrections",
                             {"BUFF量": 0,
                              "BUFF量百分比": 0,
                              "三攻": 0,
                              "光强": 0,
                              "光抗": 0,
                              "冰强": 0,
                              "冰抗": 0,
                              "力智": 0,
                              "四维": 0,
                              "技攻": 0,
                              "攻击强化": 0,
                              "攻击强化百分比": 0,
                              "攻速": 0,
                              "暗强": 0,
                              "暗抗": 0,
                              "火强": 0,
                              "火抗": 0
                              }))

    def jade_upgrade(self):
        temp = []
        from core.equipment.jade import get_jade_setinfo, get_jadefunc_by_id
        num_range = [26001, 26020]
        if self.类型 == '辅助':
            num_range = [26011, 26206]
        for jade in get_jade_setinfo():
            if jade["id"] > num_range[0] and jade["id"] <= num_range[1]:
                char = deepcopy(self)
                func = get_jadefunc_by_id(jade["id"])
                func(char, value=jade["max"])
                char.__计算前预处理()
                temp.append({
                    "id": jade["id"],
                    "name": jade["props"] + "  " + ("" if jade["max"] == 1 else ("+" + str(jade["max"]))) + jade["unit"],
                    "damage": round(char.结果计算()["total_data"], 2),
                    "order": jade["order"]
                })
        return temp

    def 异常保有率计算(self,pa,cur):
        if cur == '灼伤破冰':
            冰冻CD = min(self.异常时间['冰冻'][3],get_global_data("bd_cd",self.equVersion))
            # 不带鞋子，内置3秒结算CD
            if not self.check_equ_by_name('信守誓约的步伐'):
                冰冻CD = max(3,冰冻CD)
            # 破韧后，原本的CD是多少就是多少
            if get_global_data("control_state",self.equVersion):
                冰冻CD = min(self.异常时间['冰冻'][3],冰冻CD,get_global_data("bd_cd",self.equVersion))
            灼伤 = self.异常时间['灼伤']
            return max(1 - (2*冰冻CD+1)/(4*(灼伤[0]*灼伤[2] + 灼伤[1])),0)
        else:
            if self.get_eq_params(f'{cur}-结算') == 0:
                return 0
            持续时间 = self.异常时间[cur][0] * self.异常时间[cur][2] + self.异常时间[cur][1]
            异常CD = min(self.异常时间[cur][3],get_global_data(pa.split("_")[0] + '_cd',self.equVersion,99))
            if self.check_equ_by_name("承诺誓约的腰带"):
                异常CD = max(0.5,异常CD)
            return max(1 - (2*异常CD + 1) / (4*持续时间),0)

    def calc(self, setName: str = 'set', equipList: List[int] = [], withJade=False,withSet=False, info=None):
        self.calc_init(info, equipList)
        jade = []
        # cus = []
        merge = []
        if withJade:
            jade = self.jade_upgrade()
        # if withCus and self.类型 != '辅助':
        #     cus = self.cus_upgrade(CusPosition)
        # if withMerge and self.类型 != '辅助':
        #     merge = self.merge_upgrade()
        self.__计算前预处理()
        temp = self.结果计算()
        calc_info = {}

        if self.类型 == '辅助':
            calc_info[self.适用属性] = self.站街系数()
        elif self.类型 == '物理百分比':
            calc_info['力量'] = self.基础面板力量()
            calc_info['物理攻击'] = self.站街物理攻击力()
        elif self.类型 == '魔法百分比':
            calc_info['智力'] = self.基础面板智力()
            calc_info['魔法攻击'] = self.站街魔法攻击力()
        elif self.类型 == '物理固伤':
            calc_info['力量'] = self.基础面板力量()
            calc_info['独立攻击'] = self.站街独立攻击力()
        elif self.类型 == '魔法固伤':
            calc_info['智力'] = self.基础面板智力()
            calc_info['独立攻击'] = self.站街独立攻击力()
        calc_info['火'] = int(self.火属性强化())
        calc_info['冰'] = int(self.冰属性强化())
        calc_info['光'] = int(self.光属性强化())
        calc_info['暗'] = int(self.暗属性强化())
        calc_info['火抗'] = self.火属性抗性()
        calc_info['冰抗'] = self.冰属性抗性()
        calc_info['光抗'] = self.光属性抗性()
        calc_info['暗抗'] = self.暗属性抗性()

        for i in self.技能栏:
            倍率 = i.独立攻击力倍率(self.武器类型)
            if i.名称 not in self.skills_passive:
                continue
            if 倍率 != 1:
                self.skills_passive[i.名称]['info'].append({
                    "type": "独立攻击力",
                    "info": [round((倍率-1)*100), '所有', '']
                })
            倍率 = i.魔法攻击力倍率(self.武器类型)
            if 倍率 != 1:
                self.skills_passive[i.名称]['info'].append({
                    "type": "魔法攻击力",
                    "info": [round((倍率-1)*100), '所有', '']
                })
            倍率 = i.物理攻击力倍率(self.武器类型)
            if 倍率 != 1:
                self.skills_passive[i.名称]['info'].append({
                    "type": "物理攻击力",
                    "info": [round((倍率-1)*100), '所有', '']
                })
            倍率 = i.独立攻击力倍率进图(self.武器类型)
            if i.名称 not in self.skills_passive:
                continue
            if 倍率 != 1:
                self.skills_passive[i.名称]['info'].append({
                    "type": "独立攻击力[进图]",
                    "info": [round((倍率-1)*100), '所有', '']
                })
            倍率 = i.魔法攻击力倍率进图(self.武器类型)
            if 倍率 != 1:
                self.skills_passive[i.名称]['info'].append({
                    "type": "魔法攻击力[进图]",
                    "info": [round((倍率-1)*100), '所有', '']
                })
            倍率 = i.物理攻击力倍率进图(self.武器类型)
            if 倍率 != 1:
                self.skills_passive[i.名称]['info'].append({
                    "type": "物理攻击力[进图]",
                    "info": [round((倍率-1)*100), '所有', '']
                })
        buff = self.get_skill_by_name('BUFF')
        awake = self.get_skill_by_name('一次觉醒')

        skills_passive = {}
        for i in self.skills_passive.keys():
            if len(self.skills_passive[i].get("info",[]))>0:
                skills_passive[i] = self.skills_passive[i]

        result = {
            'id': uuid1().hex,
            'alter': self.实际名称,
            'name': self.名称,
            'role': 'buffer' if self.类型 == '辅助' else 'delear',
            'equips_forge': self.打造,
            'info': {
                # 站街
                '站街': calc_info,
                # 进图
                # '进图': {
                #     'liliang': self.站街力量(),
                #     'zhili': self.站街智力(),
                #     'wuligongji': self.站街物理攻击力(),
                #     'mofagongji': self.站街魔法攻击力(),
                #     'duligongji': self.站街独立攻击力(),
                #     'huo': 0,
                #     'bing': 0,
                #     'guang': 0,
                #     'an': 0
                # },
                # 词条
                'properties': {
                    # 攻击强化
                    '攻击强化': round(self.__攻击强化, 0),
                    'buffer_power': round(self.BUFF量(), 0),
                    'buffer_power_value': round(self.__buff量, 0),
                    'buffer_power_per': round(self.__百分比buff量*100, 2),
                    '技能攻击力': round(100*(self.技能攻击力-1), 2),
                    '面板技能攻击力': round(100*(self.__面板技能攻击力-1), 2),
                    '百分比攻击强化': round(self.__百分比攻击强化*100, 1),
                    'MP消耗量': round(self.__MP消耗量*100-100, 2),
                    '伤害比例': [self.伤害比例.get('直伤', 1), self.伤害比例.get('中毒', 0), self.伤害比例.get('灼伤', 0), self.伤害比例.get('感电', 0), self.伤害比例.get('出血', 0)],
                    '伤害系数': [self.伤害系数.get('直伤', 1), self.伤害系数.get('中毒', 1)-1, self.伤害系数.get('灼伤', 1)-1, self.伤害系数.get('感电',  1)-1, self.伤害系数.get('出血',  1)-1],
                    '技能范围': self.get_eq_params('skill_range'),
                    '技能范围∏':self.get_eq_params('skill_range_multi',1),
                    '保护罩': self.get_eq_params('protect') *(1+ self.get_eq_params('protect_max')),
                    # '无色消耗': temp['无色消耗'],
                    'apply_value': self.适用数值,
                    'buff_level': buff.等级,
                    'buff_name': buff.名称,
                    'awake_level': awake.等级,
                    'awake_name': awake.名称,
                    'buff_intstr_per': self.__buff百分比力智,
                    'buff_intstr': self.__buff固定力智,
                    'buff_attack_per': self.__buff百分比三攻,
                    'buff_attack': self.__buff固定三攻,
                    'awake_intstr_per': self.__觉醒百分比力智,
                    'awake_intstr': self.__觉醒固定力智,
                    '攻击速度': self.__攻击速度,
                    '其他攻击速度': self.__攻击速度_其他,
                    '施放速度': self.__施放速度,
                    '移动速度': self.__移动速度,
                    'cdr': temp.get('CDR', []),
                    '冷却缩减': self.冷却缩减 * (1-self.__加算冷却缩减),
                    '冷却恢复': self.冷却恢复,
                    'defense':self.get_eq_params('defense'),
                    'defense_ratio':self.get_eq_params('defense_ratio'),
                    'hurted_ratio':self.get_eq_params('hurted_ratio'),
                    'era': round((1-(1-self.get_eq_params('defense') * (1+self.get_eq_params('defense_ratio')) / (100000+self.get_eq_params('defense') * (1+self.get_eq_params('defense_ratio')))) * (1-self.get_eq_params('hurted_ratio')))*100,2)
                    # 其他老词条·····
                }
            },
            # '面板力量': self.面板力量(),
            # '面板智力': self.面板智力(),
            # '面板物理攻击力': self.面板物理攻击力(),
            # '面板魔法攻击力': self.面板魔法攻击力(),
            # '面板独立攻击力': self.面板独立攻击力(),
            'total_data': temp['buffer_addition'] if 'buffer_addition' in temp else [temp['total_data'], 0, 0, 0],
            "skills": temp["skills"],
            "skills_passive": skills_passive,
            "specificity_list":info.get("specificity_list",[]),
            "specificity":{},
            "jade": sorted(jade, key=lambda x: x["order"]),
            # "cus": cus,
            'tip_part': self.tip_part
        }

        if withSet:
            result['forge_set'] = info['forge_set']
            result['equips'] = list(map(lambda x: get_equ(self.equVersion).get_json(x), self.装备栏))
            result['merge_list'] = self.武器融合
            result['fusion_list'] = self.融合列表
            result['customize'] = info['customize']

        for 抗性 in ['出血', '中毒', '灼伤', '感电',  '冰冻', '减速', '眩晕', '诅咒', '失明', '石化', '睡眠', '混乱', '束缚']:
            result['info']['properties'][抗性+'抗性'] = self.异常抗性获取(抗性) * 100
        return result


def createCharacter(alter: str, equVersion: str = "0"):
    character: Character = None
    module_name = 'core.characters.'+alter
    try:
        character = importlib.import_module(
            module_name).classChange(equVersion)
    except Exception as ex:
        print(ex)
        print('create character ' + module_name + ' error.')
        pass
    return character
